Kelio planavimas: išsamus A-Star (A*) algoritmo įgyvendinimo vadovas

Kelio planavimas yra fundamentali problema daugelyje sričių, įskaitant robotiką, žaidimų kūrimą, logistiką ir autonomines transporto priemones. Tikslas yra rasti optimalų (arba beveik optimalų) kelią tarp pradinio taško ir tikslo taško, vengiant kliūčių pakeliui. Tarp įvairių kelio paieškos algoritmų, A-Star (A*) algoritmas išsiskiria savo efektyvumu ir universalumu.

Kas yra A-Star (A*) algoritmas?

A* yra informuotas paieškos algoritmas, reiškiantis, kad jis naudoja heuristinę funkciją, kad įvertintų kainą pasiekti tikslą iš bet kurio duoto mazgo. Jis sujungia Dijkstra algoritmo (kuris garantuoja trumpiausio kelio radimą) ir godaus geriausio pirmo paieškos (kuris yra greitesnis, bet ne visada randa optimalų kelią) privalumus. A* algoritmas prioritetizuoja mazgus, remdamasis šia įvertinimo funkcija:

f(n) = g(n) + h(n)

• f(n): Apskaičiuota pigiausio sprendimo, einančio per mazgą n, kaina.
• g(n): Tikroji kaina pasiekti mazgą n nuo pradinio mazgo.
• h(n): Apskaičiuota kaina pasiekti tikslo mazgą nuo mazgo n (heuristika).

Heuristinė funkcija, h(n), yra labai svarbi A* veikimui. Gerai parinkta heuristika gali žymiai pagreitinti paieškos procesą. Tačiau heuristika turi būti priimtina, reiškianti, kad ji niekada nepervertina kainos pasiekti tikslą. Nepriimtina heuristika gali lemti suboptimalų kelią.

Kaip veikia A-Star algoritmas: žingsnis po žingsnio

1. Inicijavimas:
   • Sukurkite atvirą sąrašą, skirtą saugoti mazgus, kuriuos reikia įvertinti.
   • Sukurkite uždarą sąrašą, skirtą saugoti mazgus, kurie jau buvo įvertinti.
   • Pridėkite pradinį mazgą į atvirą sąrašą.
   • Nustatykite g(start) = 0 ir h(start) = apskaičiuota kaina nuo pradžios iki tikslo.
   • Nustatykite f(start) = g(start) + h(start).
2. Iteracija:

   Kol atviras sąrašas nėra tuščias:

   • Gaukite mazgą su mažiausia f(n) verte iš atviro sąrašo. Pavadinkime šį mazgą dabartiniu mazgu.
   • Pašalinkite dabartinį mazgą iš atviro sąrašo ir pridėkite jį į uždarą sąrašą.
   • Jei dabartinis mazgas yra tikslo mazgas, atkurkite kelią ir grąžinkite jį.
   • Kiekvienam dabartinio mazgo kaimynui:
   • Jei kaimynas nėra pereinamas arba yra uždarame sąraše, ignoruokite jį.
   • Apskaičiuokite preliminarią g(n) vertę kaimynui (g(kaimynas) = g(dabartinis) + kaina(dabartinis iki kaimyno)).
   • Jei kaimyno nėra atvirame sąraše arba preliminari g(n) vertė yra mažesnė už kaimyno dabartinę g(n) vertę:
   • Nustatykite kaimyno g(n) vertę į preliminarią g(n) vertę.
   • Nustatykite kaimyno h(n) vertę į apskaičiuotą kainą nuo kaimyno iki tikslo.
   • Nustatykite kaimyno f(n) vertę į g(n) + h(n).
   • Nustatykite kaimyno tėvą į dabartinį mazgą.
   • Jei kaimyno nėra atvirame sąraše, pridėkite jį į atvirą sąrašą.
3. Nėra kelio:

   Jei atviras sąrašas tampa tuščias ir tikslo mazgas nebuvo pasiektas, nėra kelio nuo pradinio mazgo iki tikslo mazgo.

4. Kelio atkūrimas:

   Pasiekus tikslo mazgą, kelią galima atkurti atsekiant atgal nuo tikslo mazgo iki pradinio mazgo, sekant tėvų rodykles.

Tinkamos heuristinės funkcijos pasirinkimas

Heuristinės funkcijos pasirinkimas žymiai veikia A* algoritmo veikimą. Štai keletas įprastų heuristinių funkcijų:

• Manhatano atstumas: Apskaičiuoja koordinačių absoliučių skirtumų sumą. Tinka tinklelio pagrindu sukurtai aplinkai, kurioje judėjimas apribotas horizontaliomis ir vertikaliomis kryptimis. Formulė: h(n) = |x1 - x2| + |y1 - y2|, kur (x1, y1) yra dabartinio mazgo koordinatės, o (x2, y2) yra tikslo mazgo koordinatės. Pavyzdys: navigacija miesto kvartalais Manhetene, Niujorke.
• Euklido atstumas: Apskaičiuoja tiesią liniją tarp dviejų taškų. Tinka aplinkai, kurioje judėjimas nėra apribotas. Formulė: h(n) = sqrt((x1 - x2)^2 + (y1 - y2)^2). Pavyzdys: Trumpiausio kelio paieška dronui atvirame lauke.
• Įstrižainės atstumas: Atsižvelgia į įstrižainės judėjimą. Tinka tinklelio pagrindu sukurtai aplinkai, kurioje leidžiamas įstrižainės judėjimas. Pavyzdys: Daugelis realaus laiko strateginių žaidimų naudoja įstrižainės judėjimą.
• Čebyševo atstumas: Apskaičiuoja maksimalų koordinačių absoliučių skirtumų skaičių. Tinka, kai įstrižainės judėjimas kainuoja tiek pat, kiek ir ortogonalus judėjimas. Formulė: h(n) = max(|x1 - x2|, |y1 - y2|). Pavyzdys: Robotikos programos, kuriose judėjimas bet kuria ašimi yra vienodai brangus.

Svarbu pasirinkti priimtiną heuristiką. Naudojant nepriimtiną heuristiką, algoritmas gali rasti suboptimalų kelią. Pavyzdžiui, jei naudojate Euklido atstumą, negalite tiesiog padauginti jo iš konstantos, didesnės nei 1.

A-Star algoritmo įgyvendinimas: praktinis pavyzdys (Python)

Štai A* algoritmo įgyvendinimas Python. Šiame pavyzdyje naudojama tinklelio pagrindu sukurta aplinka.

            
import heapq

def a_star(grid, start, goal):
    """Implements the A* pathfinding algorithm.

    Args:
        grid: A 2D list representing the environment.
              0: traversable, 1: obstacle
        start: A tuple (row, col) representing the starting point.
        goal: A tuple (row, col) representing the goal point.

    Returns:
        A list of tuples representing the path from start to goal,
        or None if no path exists.
    """

    rows, cols = len(grid), len(grid[0])

    def heuristic(a, b):
        # Manhattan distance heuristic
        return abs(a[0] - b[0]) + abs(a[1] - b[1])

    def get_neighbors(node):
        row, col = node
        neighbors = []
        for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
            new_row, new_col = row + dr, col + dc
            if 0 <= new_row < rows and 0 <= new_col < cols and grid[new_row][new_col] == 0:
                neighbors.append((new_row, new_col))
        return neighbors

    open_set = [(0, start)]  # Priority queue (f_score, node)
    came_from = {}
    g_score = {start: 0}
    f_score = {start: heuristic(start, goal)}

    while open_set:
        f, current = heapq.heappop(open_set)

        if current == goal:
            path = []
            while current in came_from:
                path.append(current)
                current = came_from[current]
            path.append(start)
            path.reverse()
            return path

        for neighbor in get_neighbors(current):
            tentative_g_score = g_score[current] + 1  # Assuming cost of 1 to move to neighbor

            if neighbor not in g_score or tentative_g_score < g_score[neighbor]:
                came_from[neighbor] = current
                g_score[neighbor] = tentative_g_score
                f_score[neighbor] = tentative_g_score + heuristic(neighbor, goal)
                heapq.heappush(open_set, (f_score[neighbor], neighbor))

    return None  # No path found

# Example usage:
grid = [
    [0, 0, 0, 0, 0],
    [0, 1, 0, 1, 0],
    [0, 0, 0, 0, 0],
    [0, 1, 1, 1, 0],
    [0, 0, 0, 0, 0],
]

start = (0, 0)
goal = (4, 4)

path = a_star(grid, start, goal)

if path:
    print("Path found:", path)
else:
    print("No path found.")

            

              
                Copy
              
            
          

Paaiškinimas:

• Funkcija `a_star` priima tinklelį, pradžią ir tikslą kaip įvestį.
• Funkcija `heuristic` apskaičiuoja Manhatano atstumą.
• Funkcija `get_neighbors` grąžina galiojančius kaimyninius mazgus.
• `open_set` yra prioritetinė eilė, kurioje saugomi mazgai, kuriuos reikia įvertinti.
• Žodynas `came_from` saugo kiekvieno mazgo tėvą kelyje.
• Žodynas `g_score` saugo kiekvieno mazgo pasiekimo kainą nuo pradžios.
• Žodynas `f_score` saugo apskaičiuotą kainą pasiekti tikslą nuo kiekvieno mazgo.
• Pagrindinis ciklas kartojasi tol, kol tikslas randamas arba atviras rinkinys yra tuščias.

A* optimizavimas ir variantai

Nors A* yra galingas algoritmas, yra keletas optimizavimų ir variantų, kurie gali pagerinti jo veikimą konkrečiuose scenarijuose:

• Jump Point Search (JPS): Sumažina ištirtų mazgų skaičių „peršokdamas“ tiesius tinklelio segmentus. Veiksmingas vienodos kainos tinklelio aplinkoje.
• Theta*: Leidžia kelio paiešką, kuri neapsiriboja tinklelio kraštais. Gali rasti trumpesnius ir realistiškesnius kelius, atsižvelgiant į tiesioginį matomumą tarp mazgų.
• Iterative Deepening A* (IDA*): Naudoja gylio pirmą paiešką su kainos riba, kad apribotų atminties naudojimą. Naudinga labai didelėms paieškos erdvėms.
• Weighted A*: Modifikuoja heuristinę funkciją padauginant ją iš svorio. Gali greičiau rasti suboptimalius kelius, pirmenybę teikiant paieškai link tikslo. Naudinga, kai pakankamai gero kelio radimas greitai yra svarbesnis nei absoliučiai trumpiausio kelio radimas.
• Dynamic A* (D*): Tvarko aplinkos pokyčius po to, kai apskaičiuojamas pradinis kelias. Tinka dinamiškai aplinkai, kurioje gali atsirasti arba išnykti kliūtys. Dažniausiai naudojamas robotikoje autonominei navigacijai nenuspėjamoje aplinkoje.
• Hierarchical A*: Naudoja hierarchinį aplinkos vaizdavimą, kad sumažintų paieškos erdvę. Jis veikia pirmiausia planuojant aukšto lygio kelią ant grubaus žemėlapio vaizdo ir tada patikslinant kelią smulkesniais detalumo lygiais. Šis metodas yra naudingas planuojant ilgus kelius didelėse ir sudėtingose aplinkose.

Realaus pasaulio A-Star algoritmo pritaikymai

• Žaidimų kūrimas: Personažų judėjimas, DI navigacija ir kelio paieška ne žaidėjų personažams (NPC). Pavyzdžiai: Strateginiai žaidimai, tokie kaip StarCraft, RPG žaidimai, tokie kaip The Witcher.
• Robotika: Roboto navigacija, kelio planavimas autonominiams robotams ir kliūčių vengimas. Pavyzdžiai: Savaeigiai dulkių siurbliai, sandėlių robotai.
• Logistika ir tiekimo grandinė: Maršruto planavimas pristatymo sunkvežimiams, pristatymo maršrutų optimizavimas, siekiant sumažinti kelionės laiką ir degalų sąnaudas. Pavyzdžiai: Pristatymo tarnybos, tokios kaip FedEx, UPS ir DHL, naudoja kelio paieškos algoritmus, kad optimizuotų savo pristatymo maršrutus visame pasaulyje.
• Autonominės transporto priemonės: Kelio planavimas savaeigiams automobiliams ir dronams, užtikrinant saugią ir efektyvią navigaciją. Pavyzdžiai: Tesla Autopilot, Waymo savaeigių technologijos. Autonominės transporto priemonės turi naršyti sudėtingose miesto aplinkose, atsižvelgiant į eismo sąlygas, pėsčiųjų judėjimą ir kelių uždarymus.
• GPS navigacijos sistemos: Trumpiausio arba greičiausio maršruto paieška tarp dviejų taškų, atsižvelgiant į eismo sąlygas ir kelių uždarymus. Pavyzdžiai: Google Maps, Apple Maps.
• Medicininis vaizdavimas: Kelio planavimas minimaliai invazinei chirurgijai, nukreipiant chirurginius instrumentus per kūną, vengiant kritinių organų.
• Tinklo maršruto parinkimas: Trumpiausio kelio paieška duomenų paketams keliauti per tinklą.
• Vaizdo žaidimų lygių dizainas: automatiškai išdėstant objektus pagal kelio paieškos apribojimus.

A-Star algoritmo privalumai ir trūkumai

Privalumai:

• Optimalumas: Garantuoja trumpiausio kelio radimą, jei heuristika yra priimtina.
• Efektyvumas: Efektyvesnis nei neinformuoti paieškos algoritmai, tokie kaip pločio pirmas paieška ir gylio pirmas paieška.
• Universalumas: Gali būti naudojamas įvairiose aplinkose ir programose.

Trūkumai:

• Atminties sunaudojimas: Gali prireikti daug atminties atviriems ir uždariems sąrašams saugoti, ypač didelėms paieškos erdvėms.
• Heuristinė priklausomybė: Veikimas labai priklauso nuo heuristinės funkcijos pasirinkimo. Prastai parinkta heuristika gali žymiai sulėtinti paieškos procesą.
• Skaičiavimo kaina: f(n) įvertinimas gali būti brangus kai kurioms programoms.

Apsvarstymai dėl visuotinio įgyvendinimo

Įgyvendinant A* pasaulinėms programoms, apsvarstykite šiuos dalykus:

• Koordinačių sistemos: Naudokite atitinkamas koordinačių sistemas ir žemėlapio projekcijas geografinei vietovei. Skirtinguose regionuose naudojamos skirtingos koordinačių sistemos (pvz., WGS 84, UTM).
• Atstumo skaičiavimai: Naudokite tikslius atstumo skaičiavimo metodus, tokius kaip Haversine formulė, kad atsižvelgtumėte į Žemės kreivumą. Tai ypač svarbu planuojant ilgus atstumus.
• Duomenų šaltiniai: Naudokite patikimus ir atnaujintus žemėlapio duomenis iš patikimų šaltinių. Apsvarstykite galimybę naudoti API iš tokių tiekėjų kaip Google Maps Platform, Mapbox arba OpenStreetMap.
• Veikimo optimizavimas: Optimizuokite algoritmą, kad jis veiktų efektyviai, naudodami efektyvias duomenų struktūras ir algoritmus. Apsvarstykite galimybę naudoti tokius metodus kaip talpyklos ir erdvinis indeksavimas, kad pagreitintumėte paieškos procesą.
• Lokalizavimas: Pritaikykite algoritmą skirtingoms kalboms ir kultūriniams kontekstams. Pavyzdžiui, apsvarstykite galimybę naudoti skirtingus matavimo vienetus (pvz., kilometrus ar mylias) ir skirtingus adresų formatus.
• Duomenys realiuoju laiku: Įtraukite duomenis realiuoju laiku, tokius kaip eismo sąlygos, oras ir kelių uždarymai, kad pagerintumėte kelio planavimo tikslumą ir patikimumą.

Pavyzdžiui, kuriant pasaulinę logistikos programą, gali tekti naudoti skirtingus žemėlapio duomenų šaltinius skirtingiems regionams, nes kai kuriuose regionuose gali būti išsamesnių ir tikslesnių duomenų nei kituose. Taip pat gali tekti atsižvelgti į skirtingus transporto reglamentus ir apribojimus skirtingose šalyse.

Išvada